home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / comm / comm2 / ctsrc6k5.lha / syszm.c < prev    next >
C/C++ Source or Header  |  1996-08-29  |  16KB  |  663 lines
  1. /*
  2.  * *       syszm.c * * External protocol handlers.
  3.  */
  4. /*
  5.  * *       history * * 89Aug14 HAW  Rewritten for versatility. * 88Nov13 HAW
  6.  * Created.
  7.  */
  8. #define SYSTEM_DEPENDENT
  9. #include "ctdl.h"
  10. #include "dos.h"
  11.  
  12. int       Jsystem(char *);
  13. long      Do_Zmodem(char *files, int direction);
  14.                          /** returns TRUE if error **/
  15. /**
  16.    Contents
  17.  AddExternProtocolOptions() to system menus
  18.  AddNames()         Allows building strings of names
  19.  AddOurOpts()       add  options to a menu list.
  20.  DoesNumerous()     BATCH checking function.
  21.  EatExtMessage()    Send a bundle of messages
  22.  EatProtocol()      Eats a protocol definition line.
  23.  ExternalProtocol() Handles all external protocols
  24.  FindProtocolCode() finds a protocol value for id purposes
  25.  FindProtoName()    returns the name of the ext protocol.
  26.  FindProtocol()     work function for finding things.
  27.  InitProtocols()   initializes external protocols
  28. **/
  29. char      MakeCmdLine(char *, char *, char *miscdata, int len);
  30. void      AddName(DirEntry *);
  31. int       ExternalProtocol(int, char, char *, char *, char);
  32. typedef struct
  33.   {
  34.     char      Selector,
  35.              *Name,
  36.               Down,
  37.              *CmdLine,
  38.              *Display,
  39.               Many;
  40.     int       ProtVal;
  41.  
  42.   }
  43. PROTOCOL;
  44. char      GetSizes = FALSE;
  45. int       ExCount = 4;
  46. void     *EatProtocol(char *line);
  47. void     *FindProtocol(PROTOCOL *, int *);
  48. void      InitProtocols(void);
  49. static SListBase ExtProtocols =
  50. {
  51.   NULL, FindProtocol, NULL, NULL, EatProtocol
  52.  
  53. };
  54. static char FindCode = FALSE;
  55. extern CONFIG cfg;
  56. extern MessageBuffer msgBuf;
  57. extern aRoom roomBuf;
  58. extern char loggedIn;
  59. extern int SystemPort;
  60. extern char onConsole;              /*
  61.  
  62.                                              * Where we get stuff from
  63.                                              */
  64. extern logBuffer logBuf;
  65. char      AddStringToMCL(char *target, char *source, int len);
  66. void      EnglishWork(char *target, char Ups);
  67. char      cmdline[125];             /* we have a limit  */
  68. /*
  69.  * * InitProtocols() * * This function initializes external protocols.
  70.  */
  71. void
  72. InitProtocols()
  73. {
  74.   SYS_FILE  fn;
  75.  
  76.   makeSysName(fn, "ctdlprot.sys", &cfg.roomArea);
  77.   MakeList(&ExtProtocols, fn, NULL);
  78.  
  79. }
  80. /**
  81.   EatProtocol()
  82. This function eats a protocol line.
  83.   Format:
  84.  [selector] [1/M] [name] [u/d] [command line]
  85.  [selector] [I]   [name] [u/d] [Internal Zmodem]
  86. **/
  87. void     *
  88. EatProtocol(char *line)
  89. {
  90.   PROTOCOL *temp;
  91.   char     *c,
  92.            *err;
  93.  
  94.   if (cfg.BoolFlags.debug)
  95.     splitF(NULL, "External:%s\n", line);
  96.   err = line;
  97.   NormStr(line);
  98.   if (strLen(line) == 0)
  99.     return NULL;
  100.   temp = GetDynamic(sizeof *temp);
  101.   temp->Selector = line[0];
  102.   line += 2;
  103.   temp->Many = toUpper(line[0]);
  104.   /**
  105.      Could be "1" or "M"
  106.   **/
  107.   switch (temp->Many)
  108.     {
  109.         case '1':       /*
  110.                          * Single file, external protocol handler
  111.                          */
  112.         case 'M':       /*
  113.                          * Multiple files, external protocol handler
  114.                          */
  115.         case 'I':       /*
  116.                          * Internal Zmodem
  117.                         */
  118.           break;
  119.         default:
  120.           splitF(NULL, "Invalid Protocol in CTDLPROT.SYS\n%s\n", err);
  121.  
  122.     }
  123.   line += 2;
  124.   if ((c = strchr(line, ' ')) != NULL)
  125.     *c = 0;
  126.   temp->Name = strdup(line);
  127.   line = lbyte(line) + 1;
  128.   temp->Down = (toUpper(line[0]) == 'D') ? TRUE : FALSE;
  129.   line += 2;
  130.   temp->CmdLine = strdup(line);
  131.   temp->ProtVal = ExCount++;
  132.   sPrintf(cmdline, "%s%c\b%s", NTERM, temp->Selector, temp->Name);
  133.   temp->Display = strdup(cmdline);
  134.   return temp;
  135.  
  136. }
  137. /**
  138.  ExternalProtocol()
  139.   This function handles external protocols.  It
  140.   also checks for external message uploads/downloads.
  141. **/
  142. int
  143. ExternalProtocol(int protocol, char upload, char *mask, char *phrase,
  144.                      char Move)
  145. {
  146.   PROTOCOL *Prot;
  147.   int       toReturn;
  148.   extern long byteRate;
  149.   extern int SystemPort;
  150.   long realCount;
  151.   SpecialMessage("Status:External Protocol");
  152.   if (cfg.BoolFlags.debug)
  153.     {
  154.         splitF(NULL, "ExternalProtocol(%d,%s,%s,%s,%s)\n", protocol,
  155.         (upload ? "TRUE" : "FALSE"), mask, phrase, (Move ? "TRUE" : "FALSE"));
  156.  
  157.     };
  158.   if ((Prot = SearchList(&ExtProtocols, &protocol)) == NULL)
  159.     {
  160.         if (cfg.BoolFlags.debug) splitF(NULL, "SearchList failed to find Protocol\n");
  161.         return TRAN_FAILURE;
  162.  
  163.     };
  164.   if (Move && !setSpace(&roomBuf))
  165.     {
  166.         if (cfg.BoolFlags.debug)   splitF(NULL, "SetSpace Failed\n");
  167.         return TRAN_FAILURE;
  168.  
  169.     };
  170.   if (!upload)
  171.     {
  172.         msgBuf.mbtext[0] = 0;
  173.         wildCard(AddName, mask, FALSE, phrase, TRUE);
  174.  
  175.     }
  176.   else
  177.     strCpy(msgBuf.mbtext, mask);
  178.   if (Prot->Many == '1' || Prot->Many == 'M')   /*
  179.                                                                  * old style
  180.                                                                  */
  181.     {
  182.         if (cfg.BoolFlags.debug) splitF(NULL, "Making external command line\n");
  183.         if (!MakeCmdLine(cmdline, Prot->CmdLine, msgBuf.mbtext, sizeof cmdline - 1))
  184.           {
  185.             if (strchr(mask, '>') != NULL || strchr(mask, '<') != NULL)
  186.                 {
  187.                   if (cfg.BoolFlags.debug) splitF(NULL, "List too long\n");
  188.                   Output_Citadel_Message("FILLTL", NULL, NULL, NULL);
  189.                   if (Move)     homeSpace();
  190.                   return TRAN_FAILURE;
  191.  
  192.                 }
  193.             else if (!MakeCmdLine(cmdline, Prot->CmdLine, mask, sizeof cmdline - 1))
  194.                 {
  195.                   if (cfg.BoolFlags.debug) splitF(NULL, "List too long\n");
  196.                   Output_Citadel_Message("FILLTL", NULL, NULL, NULL);
  197.                   if (Move)  homeSpace();
  198.                   return TRAN_FAILURE;
  199.  
  200.                 }
  201.  
  202.           };
  203.  
  204.     };
  205.   if (!upload)
  206.     fileMessage(FL_START, mask, TRUE, protocol, 0l);
  207.   if (loggedIn)
  208.     printf("\n(%s)\n %s", logBuf.lbname, cmdline);
  209.   if (Prot->Many == '1' || Prot->Many == 'M')   /* old style */
  210.     {
  211.         Jsystem(cmdline);
  212.  
  213.     }
  214.   else
  215.  
  216. /**
  217.    Internal Zmodem
  218.  
  219. **/
  220.     {
  221.  
  222.     if( Do_Zmodem(msgBuf.mbtext, upload) )
  223.        return TRAN_FAILURE ;
  224.  
  225.  
  226.     };
  227.   if (!upload)
  228.     {
  229.         GetSizes = TRUE;
  230.         ExCount = 0;
  231.         strCpy(msgBuf.mbtext, "   ");
  232.         (void)wildCard(AddName, mask, Move, phrase, TRUE);
  233.         GetSizes = FALSE;
  234.         if (Move)         homeSpace();
  235.         fileMessage(FL_EX_END, mask, TRUE, protocol, 0l         /*
  236.                                                                                  * filled in
  237.                                                                                  */ );
  238.         toReturn = TRAN_SUCCESS;
  239.   /* if( realCount > 0 )transRecDown(mask, realCount); */
  240.  
  241.     }
  242.   else
  243.     {
  244.         toReturn = ((strcmp(mask, "msg") == 0) || (access(mask, 0) == 0))
  245.           ? TRAN_SUCCESS : TRAN_FAILURE;
  246.  
  247.     }
  248.   return toReturn;
  249.  
  250. }
  251. UNS_16    intrates[] =
  252. {
  253.   30, 120, 240, 480, 960, 1440, 1920, 3840, 5760
  254.  
  255. };
  256.  
  257. /*
  258.  * * MakeCmdLine() * * This function creates a command line, including
  259.  * supported substitution * parameters.  This should be detailed in this
  260.  * comment but isn't.
  261.  */
  262. char
  263. MakeCmdLine(char *target, char *source, char *miscdata, int len)
  264. {
  265.   extern int thisLog;               /*
  266.  
  267.                                              * entry currently in logBuf
  268.                                              */
  269.   char     *c,
  270.            *temp,
  271.             NoOverflow = TRUE;
  272.   int       i;
  273.   long the_bps;
  274.   for (i = 0, c = source; *c; c++)
  275.     {
  276.         if (i > len - 2)
  277.           {
  278.             NoOverflow = FALSE;
  279.             break;
  280.  
  281.           }
  282.         if (*c == '%')
  283.           {
  284.             target[i] = 0;
  285.             c++;
  286.             switch (*c)
  287.                 {
  288.                   case 'a':     /* baud rate */
  289.                     if (onConsole)
  290.                         sPrintf(lbyte(target), "%d", 0);
  291.                     else
  292.                         sPrintf(lbyte(target), "%ld",
  293.                                   (cfg.DepData.LockPort != -1) ?
  294.                             (long)(intrates[cfg.DepData.LockPort] * 10) : byteRate * 10);
  295.                     break;
  296.                   case 'b':     /* bps */
  297.                     if( onConsole )
  298.                       {
  299.                       the_bps = 0;
  300.                       }
  301.                     else if( cfg.DepData.LockPort == -1 )
  302.                       {
  303.                       the_bps = byteRate;
  304.                       }
  305.                     else
  306.                       {
  307.                       the_bps = (long)(intrates[cfg.DepData.LockPort]);
  308.                       };
  309.                     sPrintf(lbyte(target), "%ld", the_bps);
  310.                     break;
  311.                   case 'c':     /* port # */
  312.                     sPrintf(lbyte(target), "%d", SystemPort);
  313.                     break;
  314.                   case 'e':     /* log number of the user */
  315.                     sPrintf(lbyte(target), "%d", thisLog);
  316.                     break;
  317.                   case 'f':     /* ANSI code of the user  */
  318.                     sPrintf(lbyte(target), "0");
  319.                     break;
  320.                   case 'g':     /* file mask */
  321.                     NoOverflow = AddStringToMCL(target, miscdata, len);
  322.                     break;
  323.                   case 'h':
  324.                     if (byteRate != 0)
  325.                         sPrintf(lbyte(target), "COM%d", SystemPort);
  326.                     else
  327.                         strCat(target, "LOCAL");
  328.                     break;
  329.                   case 'i':
  330.                     NoOverflow = AddStringToMCL(target, roomBuf.rbname, len);
  331.                     break;
  332.                   case 'j':
  333.                     if ((temp = FindDirName(roomBuf.rbArea)) != NULL)
  334.                         NoOverflow = AddStringToMCL(target, temp, len);
  335.                     break;
  336.                   case 'k':
  337.                     sPrintf(lbyte(target), "%d", logBuf.lbwidth);
  338.                     break;
  339.                   case 'd':
  340.                     strCat(target, logBuf.lbname);
  341.                     break;
  342.  
  343.                 }
  344.             while (target[i])
  345.                 i++;
  346.  
  347.           }
  348.         else
  349.           target[i++] = *c;
  350.  
  351.     }
  352.   target[i] = 0;
  353.   if (cfg.BoolFlags.debug)
  354.     splitF(NULL, "Command Line is %d long\n", strlen(target));
  355.   return NoOverflow;
  356.  
  357. }
  358. /*
  359.  * * AddStringToMCL() * * This adds a string as needed, I guess.
  360.  */
  361. char
  362. AddStringToMCL(char *target, char *source, int len)
  363. {
  364.   if (strlen(source) + strlen(target) < len - 2)
  365.     {
  366.         strCat(target, source);
  367.         return TRUE;
  368.  
  369.     }
  370.   else
  371.     {
  372.         strncpy(lbyte(target), source, len - strlen(target) - 1);
  373.         target[len - 1] = 0;
  374.         return FALSE;
  375.  
  376.     }
  377.  
  378. }
  379. static char **TheOpts,
  380.           IsUpload;
  381.  
  382. /*
  383.  * * AddExternProtocolOptions() * * This function adds external protocol
  384.  * options to system menus.
  385.  */
  386. void
  387. AddExternProtocolOptions(char **Opts, char upload)
  388. {
  389.   void      AddOurOpts();
  390.  
  391.   TheOpts = Opts;
  392.   IsUpload = upload;
  393.   RunList(&ExtProtocols, AddOurOpts);
  394.  
  395. }
  396. /*
  397.  * * AddOurOpts() * * This function does the actual work of adding an option
  398.  * to a menu list.
  399.  */
  400. void
  401. AddOurOpts(PROTOCOL * d)
  402. {
  403.   if ((d->Down && IsUpload) ||
  404.         (!d->Down && !IsUpload))
  405.     return;
  406.   ExtraOption(TheOpts, d->Display);
  407.  
  408. }
  409. /*
  410.  * * FindProtocolCode() * * This function finds a protocol value for id
  411.  * purposes.
  412.  */
  413. int
  414. FindProtocolCode(int c, char upload)
  415. {
  416.   PROTOCOL *Prot;
  417.  
  418.   FindCode = TRUE;
  419.   IsUpload = upload;
  420.   if (isalpha(c))
  421.     c = toUpper(c);
  422.   Prot = SearchList(&ExtProtocols, &c);
  423.   FindCode = FALSE;
  424.   if (Prot == NULL)
  425.     return -1;
  426.   return Prot->ProtVal;
  427.  
  428. }
  429. /*
  430.  * * FindProtoName() * * This function returns the name of the external
  431.  * protocol.
  432.  */
  433. char     *
  434. FindProtoName(int protocol)
  435. {
  436.   PROTOCOL *Prot;
  437.  
  438.   if ((Prot = SearchList(&ExtProtocols, &protocol)) == NULL)
  439.     return NULL;
  440.   return Prot->Name;
  441.  
  442. }
  443. /*
  444.  * * FindProtocol() * * This work function helps find a protocol in a list.
  445.  */
  446. void     *
  447. FindProtocol(PROTOCOL * d, int *val)
  448. {
  449.   if (FindCode)
  450.     {
  451.         if (*val == d->Selector && IsUpload != d->Down)
  452.           return d;
  453.  
  454.     }
  455.   else if (*val == d->ProtVal)
  456.     return d;
  457.   return NULL;
  458.  
  459. }
  460. /*
  461.  * * DoesNumerous() * * Does this protocol support BATCH downloads?
  462.  */
  463. char
  464. DoesNumerous(int protocol)
  465. {
  466.   PROTOCOL *Prot;
  467.  
  468.   if ((Prot = SearchList(&ExtProtocols, &protocol)) == NULL)
  469.     return FALSE;
  470.   return (char) (Prot->Many == 'M' || Prot->Many == 'I');
  471.  
  472. }
  473. /*
  474.  * * EatExtMessage() * * This function eat a message upload using an
  475.  * external protocol.  It returns * TRAN_SUCCESS on success, TRAN_FAILURE
  476.  * otherwise.
  477.  */
  478. int
  479. EatExtMessage(int protocol)
  480. {
  481.   struct FileInfoBlock *info;
  482.   int       result;
  483.   extern char TDirBuffer[];
  484.   char      dir[80];
  485.  
  486.   MakeTempDir();
  487.   if ((result = ExternalProtocol(protocol, TRUE, "msg", "", FALSE)) == TRAN_SUCCESS)
  488.     {
  489.         chdir(TDirBuffer);
  490.         info = (struct FileInfoBlock *) calloc(1, sizeof(struct FileInfoBlock));
  491.  
  492.         if (info == NULL)
  493.           {
  494.             splitF(NULL, "Unable to get memory for info buffer(syszm)\n");
  495.  
  496.           }
  497.         else
  498.           {
  499.             result = dfind(info, ALL_FILES, 0); /*
  500.                                                                  * get the filename
  501.                                                                  */
  502.             if (result == 0)
  503.                 {
  504.                   if (cfg.BoolFlags.debug)
  505.                     splitF(NULL, "Ingesting:", info->fib_FileName);
  506.                   ingestFile(info->fib_FileName, &msgBuf);
  507.                   unlink(info->fib_FileName);
  508.  
  509.                 }
  510.             else
  511.                 splitF(NULL, "No file found!(syszm)\n");
  512.             free(info);
  513.  
  514.           };
  515.  
  516.     }
  517.   else
  518.     {
  519.         splitF(NULL, "Transfer failed(syszm)\n");
  520.         if (cfg.BoolFlags.debug)
  521.           {
  522.             (void) getcd(0, dir);
  523.             splitF(NULL, " Dir:%s\n Other:%s\n", dir, TDirBuffer);
  524.  
  525.           };
  526.  
  527.     };
  528.   homeSpace();
  529.   rmdir(TDirBuffer);
  530.   return result;
  531.  
  532. }
  533. /*
  534.  * * AddName() * * This function is used in conjunction with wildCard to
  535.  * generate a list * of names, optionally with filesizes in parenthesis
  536.  * 4/line.  This is used * to generate a command line or a report in
  537.  * FILELOG.SYS.
  538.  */
  539. void
  540. AddName(DirEntry * file)
  541. {
  542.   if (strLen(msgBuf.mbtext) > MAXTEXT - 200)
  543.     {
  544.         if (GetSizes)
  545.           strCat(msgBuf.mbtext, ".");
  546.  
  547.     }
  548.   else
  549.     {
  550.         sPrintf(lbyte(msgBuf.mbtext), " %s", file->unambig);
  551.         if (GetSizes)
  552.           {
  553.             sPrintf(lbyte(msgBuf.mbtext), " (%ld)", file->FileSize);
  554.             if (++ExCount == 4)
  555.                 {
  556.                   strCat(msgBuf.mbtext, "\n   ");
  557.                   ExCount = 0;
  558.  
  559.                 }
  560.  
  561.           }
  562.  
  563.     }
  564.  
  565. }
  566. static char *msgText,
  567.           UpsOnly;
  568.  
  569. /*
  570.  * * UpProtsEnglish() * * This generates a list of upload protocol names.
  571.  * It is used by the help * system.
  572.  */
  573. void
  574. UpProtsEnglish(char *target)
  575. {
  576.   EnglishWork(target, TRUE);
  577.  
  578. }
  579. /*
  580.  * * DownProtsEnglish() * * This function generates a list of download
  581.  * protocol names for use by the * help system.
  582.  */
  583. void
  584. DownProtsEnglish(char *target)
  585. {
  586.   EnglishWork(target, FALSE);
  587.  
  588. }
  589. /*
  590.  * * EnglishWork() * * This function does the real work of generating names.
  591.  */
  592. void      List_Names(PROTOCOL *);
  593. void
  594. EnglishWork(char *target, char Ups)
  595. {
  596.   char     *c;
  597.  
  598.   target[0] = 0;
  599.   msgText = target;
  600.   UpsOnly = Ups;
  601.   RunList(&ExtProtocols, List_Names);
  602.   if ((c = strrchr(target, ',')) == NULL)
  603.     strCpy(target, "None.");
  604.   else
  605.     strCpy(c, ".");
  606.  
  607. }
  608. /*
  609.  * * List_Names() * * This function helps build the list of protocols
  610.  * available.
  611.  */
  612. void
  613. List_Names(PROTOCOL * d)
  614. {
  615.   char     *c;
  616.  
  617.   if (UpsOnly != d->Down)
  618.     {
  619.         c = lbyte(msgText);
  620.         sPrintf(c, "<%c>%s, ", d->Selector, (d->Selector == d->Name[0]) ?
  621.                   d->Name + 1 : d->Name);
  622.  
  623.     }
  624.  
  625. }
  626. /*
  627.  * * ExternalTransfer() * * This function is used by the network for
  628.  * external protocol transfers.
  629.  */
  630. char
  631. ExternalTransfer(int protocol, char *filename)
  632. {
  633.   PROTOCOL *Prot;
  634.   char     *name,
  635.            *fn;
  636.  
  637.   if ((Prot = SearchList(&ExtProtocols, &protocol)) == NULL)
  638.     return FALSE;
  639.   fn = strdup(filename);
  640.   if ((name = strrchr(fn, '\\')) != NULL)
  641.     {
  642.         *name++ = 0;
  643.         chdir(fn);
  644.  
  645.     }
  646.   else
  647.     {
  648.         name = fn;
  649.  
  650.     }
  651.   if (!MakeCmdLine(cmdline, Prot->CmdLine, name, sizeof cmdline - 1))
  652.     {
  653.         free(fn);
  654.         return FALSE;
  655.  
  656.     }
  657.   Jsystem(cmdline);
  658.   free(fn);
  659.   homeSpace();
  660.   return TRUE;
  661.  
  662. }
  663.